home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_gwu / ilist.c < prev    next >
C/C++ Source or Header  |  1996-01-30  |  11KB  |  636 lines
  1. /*
  2.  * Copyright (C) 1985-1992  New York University
  3.  * 
  4.  * This file is part of the Ada/Ed-C system.  See the Ada/Ed README file for
  5.  * warranty (none) and distribution info and also the GNU General Public
  6.  * License for more details.
  7.  
  8.  */
  9.  
  10. /* i1_list - list single instruction */
  11.  
  12. /* Include standard header modules */
  13. #include <stdlib.h>
  14. #include <stdio.h>
  15. #include "config.h"
  16. #include "int.h"
  17. #include "ivars.h"
  18. #include "intap.h"
  19. #include "opnamep.h"
  20. #include "ilistp.h"
  21.  
  22. #ifdef DEBUG_FULL_STACK
  23. static void stdump(int);
  24. #endif
  25. static unsigned int dump_byte(int *, char *);
  26. static int dump_word(int *, char *);
  27. static void dump_gad(int *, char *);
  28.  
  29. #define DUMP_BYTE dump_byte(ip, curcode)
  30. #define DUMP_WORD dump_word(ip, curcode)
  31. #define DUMP_LAD  dump_word(ip, curcode)
  32. #define DUMP_GAD  dump_gad(ip, curcode)
  33.  
  34. void i_list1(int *ip, char *curcode)                            /*;i_list1*/
  35. {
  36.  
  37.     unsigned int     opcode;
  38.     int     jump, fjump;
  39.     long    lvalue;
  40.     float   fvalue;
  41.  
  42.     /* This procedure lists one instruction, advancing the first
  43.      * argument ip to point to the next instruction.
  44.      * It was obtained by editing a copy of the main_loop procedure
  45.      * and should be modified whenever a change is made in inta.c
  46.      * to the way in which instructions are decoded.
  47.      */
  48.     if (debug_trace) {
  49.         printf("tp=%1d,sp=%3d,sfp=%3d,bfp=%3d,exr=%2d,lin=%2d,tos=%3d,",
  50.           tp    ,sp    ,sfp    ,bfp    ,exr    ,lin    ,cur_stackptr);
  51.         printf("cs=%2d,ip=%3d\n",cs,*ip);
  52.     }
  53.     else
  54.         printf("tos=%3d,cs=%2d,ip=%3d  ",cur_stackptr,cs,*ip);
  55. #ifdef DEBUG_FULL_STACK
  56.     stdump(sfp);
  57. #endif
  58.     opcode = (unsigned ) curcode[*ip] & 0xff;
  59.     *ip += 1;
  60.     printf("%s ", op_name(opcode)); /* debug */
  61.     switch(opcode) {
  62.  
  63.     case I_NOP:
  64.         break;
  65.  
  66.         /* Instructions Dealing with Tasking */
  67.  
  68.     case I_ABORT:
  69.         DUMP_WORD;        /* number of tasks in stack */
  70.         break;
  71.  
  72.     case I_ACTIVATE:
  73.         break;
  74.  
  75.     case I_ACTIVATE_NEW_L:
  76.         DUMP_LAD;
  77.         break;
  78.  
  79.     case I_ACTIVATE_NEW_G:
  80.     case I_CREATE_TASK_G:
  81.         DUMP_GAD;
  82.         break;
  83.  
  84.     case I_CREATE_TASK_L:
  85.         DUMP_LAD;
  86.         break;
  87.  
  88.     case I_POP_TASKS_DECLARED_G:
  89.         DUMP_GAD;
  90.         break;
  91.  
  92.     case I_POP_TASKS_DECLARED_L:
  93.         DUMP_LAD;
  94.         break;
  95.  
  96.     case I_LINK_TASKS_DECLARED:
  97.     case I_CURRENT_TASK:
  98.         break;
  99.  
  100.     case I_END_ACTIVATION:
  101.         DUMP_BYTE;
  102.         break;
  103.  
  104.     case I_END_RENDEZVOUS:
  105.         break;
  106.  
  107.     case I_ENTRY_CALL:
  108.         DUMP_WORD;
  109.         break;
  110.  
  111.     case I_RAISE_IN_CALLER:
  112.         break;
  113.  
  114.     case I_SELECTIVE_WAIT:
  115.         DUMP_WORD;        /* number of alternatives */
  116.         break;
  117.  
  118.     case I_TERMINATE:
  119.         DUMP_BYTE;
  120.         break;
  121.  
  122.     case I_TIMED_ENTRY_CALL:
  123.     case I_WAIT:         /* delay */
  124.         break;
  125.     case I_CREATE_COPY_B:
  126.     case I_CREATE_COPY_W:
  127.         printf(" ( %d ) ",TOS);
  128.     case I_CREATE_B:
  129.     case I_CREATE_W:
  130.     case I_CREATE_L:
  131.     case I_CREATE_A:
  132.     case I_CREATE_STRUC:
  133.     case I_CREATE_COPY_STRUC:
  134.     case I_CREATE_COPY_L:
  135.     case I_CREATE_COPY_A:
  136.  
  137.         break;
  138.  
  139.     case I_DECLARE_B:
  140.     case I_DECLARE_W:
  141.     case I_DECLARE_L:
  142.     case I_DECLARE_A:
  143.         DUMP_WORD;
  144.         break;
  145.  
  146.     case I_ALLOCATE:
  147.         break;
  148.  
  149.     case I_ALLOCATE_COPY_G:
  150.         DUMP_GAD;
  151.         break;
  152.  
  153.     case I_ALLOCATE_COPY_L:
  154.         DUMP_LAD;
  155.         break;
  156.  
  157.     case I_UPDATE:
  158.     case I_UPDATE_AND_DISCARD:
  159.         DUMP_WORD;
  160.         break;
  161.  
  162.     case I_UNCREATE:
  163.         printf(" ( %d  %d ) ",TOSM(1),TOS);
  164.         break;
  165.         /* should withdraw the variable from bf_data_link TBSL */
  166.  
  167.         /* Data Transfer Instructions */
  168.  
  169.     case I_COMPARE_B:
  170.     case I_COMPARE_W:
  171.     case I_DEREF_B:
  172.     case I_DEREF_W:
  173.     case I_DEREF_L:
  174.     case I_DEREF_D:
  175.     case I_DEREF_A:
  176.         printf(" ( %d  %d ) ",TOSM(1),TOS);
  177.         break;
  178.  
  179.     case I_COMPARE_L:
  180.         printf(" ( %ld  %ld ) ",TOSML(1),TOSL);
  181.         break;
  182.  
  183.     case I_COMPARE_A:
  184.         printf(" ( %d  %d  %d  %d ) ",TOSM(3),TOSM(2),TOSM(1),TOS);
  185.     case I_COMPARE_ARRAYS:
  186.     case I_COMPARE_STRUC:
  187.         break;
  188.  
  189.     case I_DISCARD_ADDR:
  190.         DUMP_WORD;
  191.         break;
  192.  
  193.     case I_DUPLICATE_B:
  194.     case I_DUPLICATE_W:
  195.         printf(" ( %d ) ",TOS);
  196.         break;
  197.  
  198.     case I_DUPLICATE_L:
  199.         printf(" ( %ld ) ",TOSL);
  200.         break;
  201.  
  202.     case I_DUPLICATE_A:
  203.         printf(" ( %d  %d ) ",TOSM(1),TOS);
  204.         break;
  205.  
  206.     case I_INDIRECT_MOVE_B:
  207.     case I_INDIRECT_MOVE_W:
  208.     case I_INDIRECT_MOVE_L:
  209.     case I_INDIRECT_MOVE_A:
  210.         printf(" ( %d  %d  %d  %d ) ",TOSM(3),TOSM(2),TOSM(1),TOS);
  211.         break;
  212.  
  213.     case I_INDIRECT_POP_B_G:
  214.     case I_INDIRECT_POP_W_G:
  215.         DUMP_GAD;
  216.         break;
  217.  
  218.     case I_INDIRECT_POP_L_G:
  219.     case I_INDIRECT_POP_A_G:
  220.         DUMP_GAD;
  221.         break;
  222.  
  223.     case I_INDIRECT_POP_B_L:
  224.     case I_INDIRECT_POP_W_L:
  225.     case I_INDIRECT_POP_L_L:
  226.     case I_INDIRECT_POP_A_L:
  227.         DUMP_LAD;
  228.         break;
  229.  
  230.     case I_MOVE_B:
  231.     case I_MOVE_W:
  232.     case I_MOVE_L:
  233.     case I_MOVE_A:
  234.         printf(" ( %d  %d ) ",TOSM(2),TOSM(1));
  235.         break;
  236.  
  237.     case I_POP_B_G:
  238.     case I_POP_W_G:
  239.         printf(" ( %d ) ",TOS);
  240.         DUMP_GAD;
  241.         break;
  242.  
  243.     case I_POP_L_G:
  244.     case I_POP_A_G:
  245.         DUMP_GAD;
  246.         break;
  247.  
  248.     case I_POP_B_L:
  249.     case I_POP_W_L:
  250.         printf(" ( %d ) ",TOS);
  251.     case I_POP_L_L:
  252.     case I_POP_A_L:
  253.         DUMP_LAD;
  254.         break;
  255.  
  256.     case I_PUSH_B_G:
  257.     case I_PUSH_W_G:
  258.     case I_PUSH_L_G:
  259.     case I_PUSH_A_G:
  260.         DUMP_GAD;
  261.         break;
  262.  
  263.     case I_PUSH_B_L:
  264.     case I_PUSH_W_L:
  265.     case I_PUSH_L_L:
  266.     case I_PUSH_A_L:
  267.         DUMP_LAD;
  268.         break;
  269.  
  270.     case I_PUSH_EFFECTIVE_ADDRESS_G:
  271.     case I_PUSH_IMMEDIATE_A:
  272.         DUMP_GAD;
  273.         break;
  274.  
  275.     case I_PUSH_EFFECTIVE_ADDRESS_L:
  276.         jump = sfp + dump_word(ip, curcode);
  277.         printf(" (%d  %d)",cur_stack[jump], cur_stack[jump+1]);
  278.         break;
  279.  
  280.     case I_PUSH_IMMEDIATE_B:
  281.         DUMP_WORD;
  282.         break;
  283.  
  284.     case I_PUSH_IMMEDIATE_W:
  285.         DUMP_WORD;
  286.         break;
  287.  
  288.     case I_PUSH_IMMEDIATE_L:
  289. #ifdef ALIGN_WORD
  290.         lvalue = get_long(LONG(curcode + *ip));
  291.         fvalue = lvalue;
  292. #else
  293.         lvalue = *LONG(curcode + *ip);
  294.         fvalue = *((float *)(curcode + *ip));
  295. #endif
  296.         printf(" %ld  %15.3e ", lvalue,fvalue);
  297.         *ip += sizeof(long);
  298.         break;
  299.  
  300.         /* Floating Point Instructions */
  301.  
  302.     case I_FLOAT_ADD_L:
  303.     case I_FLOAT_SUB_L:
  304.     case I_FLOAT_MUL_L:
  305.     case I_FLOAT_DIV_L:
  306.     case I_FLOAT_COMPARE_L:
  307.         fvalue = *((float *)(cur_stack+cur_stackptr+1-2*WORDS_FLOAT));
  308.         printf(" ( %e  %e ) ",fvalue,TOSF);
  309.         break;
  310.  
  311.     case I_FLOAT_POW_L:
  312.         fvalue = *((float *)(cur_stack+cur_stackptr-WORDS_FLOAT));
  313.         printf(" ( %e  %d ) ",fvalue,TOS);
  314.         break;
  315.  
  316.     case I_FLOAT_NEG_L:
  317.     case I_FLOAT_ABS_L:
  318.         printf(" ( %e ) ",TOSF);
  319.         break;
  320.  
  321.     case I_ADD_B:
  322.     case I_ADD_W:
  323.         printf(" ( %d  %d ) ",TOSM(1),TOS);
  324.     case I_ADD_L:
  325.         break;
  326.  
  327.     case I_ADD_IMMEDIATE_B:
  328.         printf(" ( %d ) ",TOS);
  329.         DUMP_WORD;
  330.         break;
  331.  
  332.     case I_ADD_IMMEDIATE_W:
  333.         printf(" ( %d ) ",TOS);
  334.         DUMP_WORD;
  335.         break;
  336.  
  337.     case I_ADD_IMMEDIATE_L:
  338.         lvalue = *(LONG(curcode + *ip));
  339.         printf(" ( %ld ) %ld ",TOSL,lvalue);
  340.         *ip += WORDS_LONG;
  341.         break;
  342.  
  343.     case I_DIV_B:
  344.     case I_DIV_W:
  345.     case I_DIV_L:
  346.     case I_REM_B:
  347.     case I_REM_W:
  348.     case I_REM_L:
  349.     case I_MOD_B:
  350.     case I_MOD_W:
  351.     case I_MOD_L:
  352.     case I_MUL_B:
  353.     case I_MUL_W:
  354.     case I_MUL_L:
  355.     case I_POW_B:
  356.     case I_POW_W:
  357.     case I_POW_L:
  358.     case I_FIX_MUL:
  359.     case I_FIX_DIV:
  360.         printf(" ( %d  %d ) ",TOSM(1),TOS);
  361.         break;
  362.  
  363.     case I_CONVERT_TO_L:
  364.         DUMP_LAD;
  365.         break;
  366.  
  367.     case I_CONVERT_TO_G:
  368.         DUMP_GAD;
  369.         break;
  370.  
  371.     case I_NEG_B:
  372.     case I_NEG_W:
  373.     case I_NEG_L:
  374.     case I_ABS_B:
  375.     case I_ABS_W:
  376.     case I_ABS_L:
  377.     case I_NOT:
  378.     case I_AND:
  379.     case I_XOR:
  380.     case I_OR:
  381.     case I_IS_EQUAL:
  382.     case I_IS_GREATER:
  383.     case I_IS_GREATER_OR_EQUAL:
  384.     case I_IS_LESS:
  385.     case I_IS_LESS_OR_EQUAL:
  386.         printf(" ( %d ) ",TOS);
  387.     case I_MEMBERSHIP:
  388.         break;
  389.  
  390.     case I_QUAL_RANGE_G:
  391.         DUMP_GAD;
  392.         break;
  393.  
  394.     case I_QUAL_RANGE_L:
  395.         DUMP_LAD;
  396.         break;
  397.  
  398.     case I_QUAL_DISCR_G:
  399.         DUMP_GAD;
  400.         break;
  401.  
  402.     case I_QUAL_DISCR_L:
  403.         DUMP_LAD;
  404.         break;
  405.  
  406.     case I_QUAL_INDEX_G:
  407.         DUMP_GAD;
  408.         break;
  409.  
  410.     case I_QUAL_INDEX_L:
  411.         DUMP_LAD;
  412.         break;
  413.  
  414.     case I_QUAL_SUB_G:
  415.         DUMP_GAD;
  416.         break;
  417.  
  418.     case I_QUAL_SUB_L:
  419.         DUMP_LAD;
  420.         break;
  421.  
  422.     case I_SUB_B:
  423.     case I_SUB_W:
  424.     case I_SUB_L:
  425.  
  426.     case I_ARRAY_CATENATE:
  427.     case I_ARRAY_MOVE:
  428.     case I_ARRAY_SLICE:
  429.     case I_ARRAY_AND:
  430.     case I_ARRAY_OR:
  431.     case I_ARRAY_XOR:
  432.     case I_ARRAY_NOT:
  433.         break;
  434.  
  435.         /* Record Instructions */
  436.  
  437.     case I_RECORD_MOVE_G:
  438.         DUMP_GAD;
  439.         break;
  440.  
  441.     case I_RECORD_MOVE_L:
  442.         DUMP_LAD;
  443.         break;
  444.  
  445.         /* Attributes */
  446.  
  447.     case I_ATTRIBUTE:
  448.         DUMP_WORD; /* attribute */
  449.         break;
  450.  
  451.     case I_ENTER_BLOCK:
  452.     case I_LEAVE_BLOCK:
  453.     case I_EXIT_BLOCK:
  454.         break;
  455.  
  456.     case I_CALL_L:
  457.         DUMP_LAD;
  458.         break;
  459.  
  460.     case I_CALL_G:
  461.         DUMP_GAD;
  462.         break;
  463.  
  464.     case I_CALL_PREDEF:
  465.         DUMP_BYTE;
  466.         break;
  467.  
  468.     case I_CALL_INTERFACE:
  469.         DUMP_WORD;
  470.         break;
  471.  
  472.     case I_CASE_B:
  473.     case I_CASE_W:
  474.     case I_CASE_L:
  475.         printf(" ( %d ) case table :\n",TOS);
  476.         printf(" value ");
  477.         DUMP_WORD;  /* nb */
  478.         printf(" jump ");
  479.         fjump = DUMP_WORD;
  480.         printf("\n");
  481.         for (; *ip < fjump;) {
  482.             printf(" value ");
  483.             DUMP_WORD; /* nb */
  484.             printf(" jump ");
  485.             jump = DUMP_WORD;
  486.             printf("\n");
  487.             fjump = ((fjump < jump) ? fjump : jump);
  488.         }
  489.         break;
  490.  
  491.     case I_RETURN_B:
  492.     case I_RETURN_W:
  493.         DUMP_WORD;
  494.         printf(" ( %d ) ",TOS);
  495.         break;
  496.  
  497.     case I_RETURN_L:
  498.         DUMP_WORD;
  499.         printf(" ( %d %e ) ",TOS,TOSF);
  500.         break;
  501.  
  502.     case I_RETURN_A:
  503.         DUMP_WORD;
  504.         printf(" ( %d %d ) ",TOSM(1),TOS);
  505.         break;
  506.  
  507.     case I_RETURN_STRUC:
  508.         DUMP_WORD;
  509.         break;
  510.  
  511.     case I_END_FOR_LOOP_B:
  512.     case I_END_FOR_LOOP_W:
  513.     case I_END_FOR_LOOP_L:
  514.     case I_END_FORREV_LOOP_B:
  515.     case I_END_FORREV_LOOP_W:
  516.     case I_END_FORREV_LOOP_L:
  517.  
  518.     case I_JUMP_IF_FALSE:
  519.     case I_JUMP_IF_TRUE:
  520.     case I_JUMP_IF_GREATER:
  521.     case I_JUMP_IF_GREATER_OR_EQUAL:
  522.     case I_JUMP_IF_LESS:
  523.     case I_JUMP_IF_LESS_OR_EQUAL:
  524.         printf(" ( %d ) ",TOS);
  525.         DUMP_WORD;
  526.         break;
  527.     case I_JUMP:
  528.         DUMP_WORD;
  529.         break;
  530.  
  531.         /* Miscellanous Instructions */
  532.  
  533.     case I_LOAD_EXCEPTION_REGISTER:
  534.     case I_INSTALL_HANDLER:
  535.         DUMP_WORD;
  536.         break;
  537.  
  538.     case I_RAISE:
  539.         break;
  540.  
  541.     case I_RESTORE_STACK_POINTER:
  542.         DUMP_WORD;
  543.         break;
  544.  
  545.     case I_SAVE_STACK_POINTER:
  546.         break;
  547.  
  548.     case I_STMT:
  549.         DUMP_WORD;
  550.         break;
  551.  
  552.     case I_SUBSCRIPT:
  553.         break;
  554.  
  555.     case I_SELECT:
  556.         DUMP_WORD;
  557.         break;
  558.  
  559.     case I_TEST_EXCEPTION_REGISTER:
  560.         DUMP_WORD;
  561.         break;
  562.  
  563.     case I_TYPE_LOCAL:
  564.         DUMP_GAD;
  565.         break;
  566.  
  567.     case I_TYPE_GLOBAL:
  568.         DUMP_GAD;
  569.         break;
  570.  
  571.     case I_SUBPROGRAM:
  572.         DUMP_LAD;
  573.         break;
  574.  
  575.     default:
  576.         printf("bad opcode");
  577.  
  578.     }                /* end switch on operation code */
  579.     printf(" \n");
  580. }
  581.  
  582. #ifdef DEBUG_FULL_STACK
  583. /* give full stack dump for each instruction (use in desparation!) */
  584. static void stdump(int pd)            /*;stdump*/
  585. {
  586.     /* stack dump p is current value of sfp */
  587.     int i;
  588.     printf("stdump sfp %d %d\n",pd,pd-18);
  589.     for (i= (-18); ;i++) {
  590.         if ((pd+i) <0) continue;
  591.         if ((pd+i)>cur_stackptr) break;
  592.         printf("%6d %03d ", cur_stack[pd+i], pd+i);
  593.         if (i%7 == 0) printf("\n");
  594.     }
  595.     printf("\n");
  596. }
  597. #endif
  598.  
  599. static unsigned int dump_byte(int *ip, char *curcode)            /*;dump_byte*/
  600. {
  601.     unsigned int     byte;
  602.     /*byte = curcode[*ip++];*/
  603.     byte = (unsigned) curcode[*ip];
  604.     byte = byte & 0xff;
  605.     *ip += 1;
  606.     printf(" %u ", byte);
  607.     return byte;
  608. }
  609.  
  610. static int dump_word(int *ip, char *curcode)                    /*;dump_word*/
  611. {
  612.     int     w;
  613. #ifdef ALIGN_WORD
  614.     w = get_int((int *)(curcode + *ip));
  615. #else
  616.     w = *((int *)(curcode + *ip));
  617. #endif
  618.     printf(" %d ", w);
  619.     *ip += sizeof(int);
  620.     return w;
  621. }
  622.  
  623. static void dump_gad(int *ip, char *curcode)                    /*;dump_gad*/
  624. {
  625.     unsigned int     bse, off;
  626.     bse = (int) curcode[*ip];
  627.     *ip += 1;
  628. #ifdef ALIGN_WORD
  629.     off = get_int((int *)(curcode + *ip));
  630. #else
  631.     off = *((int *)(curcode + *ip));
  632. #endif
  633.     *ip += sizeof(int);
  634.     printf(" %3u %5u ", bse, off);
  635. }
  636.